home *** CD-ROM | disk | FTP | other *** search
/ Chip 2005 June / ccd0605.iso / Software / Freeware / Programare / highlight / highlight-W32GUI-2.2-10b-Setup.exe / {app} / src / languagedefinition.cpp < prev    next >
C/C++ Source or Header  |  2005-03-31  |  9KB  |  299 lines
  1. /***************************************************************************
  2.                           languagedefinition.cpp  -  description
  3.                              -------------------
  4.     begin                : Wed Nov 28 2001
  5.     copyright            : (C) 2001 by Andre imon
  6.     email                : andre.simon1@gmx.de
  7.  ***************************************************************************/
  8.  
  9. /***************************************************************************
  10.  *                                                                         *
  11.  *   This program is free software; you can redistribute it and/or modify  *
  12.  *   it under the terms of the GNU General Public License as published by  *
  13.  *   the Free Software Foundation; either version 2 of the License, or     *
  14.  *   (at your option) any later version.                                   *
  15.  *                                                                         *
  16.  ***************************************************************************/
  17.  
  18. #include "languagedefinition.h"
  19.  
  20. using namespace std;
  21.  
  22. namespace highlight {
  23.  
  24. LanguageDefinition::LanguageDefinition():
  25.     ignoreCase(false),
  26.     disableHighlighting(false),
  27.     allowExtEscape(false),
  28.     vhdl_mode(false),
  29.     java_mode(false),
  30.     allowNestedComments(true),
  31.     fullLineComment(false),
  32.     reformatCode(false)
  33. {}
  34.  
  35. int LanguageDefinition::isKeyword(const string &s)
  36. {
  37.   if (s.length())
  38.     {
  39.       if (keywords.count(s)){
  40.         return keywords[s];
  41.       }
  42.       else if (prefixes.count(s[0])){
  43.         return prefixes[s[0]];
  44.       }
  45.     }
  46.   return 0;
  47. }
  48.  
  49. bool LanguageDefinition::isPrefix(unsigned char c)
  50. {
  51.   return ( prefixes.count(c));
  52. }
  53.  
  54. void LanguageDefinition::addSimpleSymbol(stringstream& symbolStream,
  55.                                         State state,
  56.                                         const string& paramValues ) {
  57.   istringstream valueStream(paramValues);
  58.   bool valExists=false;
  59.   string value;
  60.    while (valueStream >> value)
  61.     {
  62.       symbolStream << " " << value;
  63.       valExists = true;
  64.     }
  65.   if (valExists)
  66.     {
  67.       symbolStream << " " << state;
  68.     }
  69. }
  70.  
  71. void LanguageDefinition::addDelimiterSymbol(stringstream& symbolStream,
  72.                                         State stateBegin, State stateEnd,
  73.                                         const string& paramValues,
  74.                                         unsigned int classID) {
  75.   istringstream valueStream(paramValues);
  76.   string delimPrefix, delimSuffix;
  77.   while (valueStream>>delimPrefix){
  78.     valueStream >> delimSuffix;
  79.     symbolStream << " "<<delimPrefix <<" " << stateBegin;
  80.     symbolStream <<" "<< delimSuffix<<" "<< stateEnd;
  81.     delimiterPrefixes.insert(make_pair(delimPrefix, classID));
  82.   };
  83. }
  84.  
  85. bool LanguageDefinition::getFlag( string& paramValue){
  86.       return (StringTools::lowerCase(paramValue)=="true");
  87. }
  88.  
  89. unsigned char LanguageDefinition::getSymbol(const string& paramValue){
  90.       istringstream valueStream(paramValue);
  91.       unsigned char symbol;
  92.       valueStream >> symbol;
  93.       return symbol;
  94. }
  95.  
  96. void LanguageDefinition::addKeywords(const string &kwList,
  97.                                      int classID){
  98.   istringstream valueStream(kwList);
  99.   string keyword;
  100.   while (valueStream >> keyword){
  101.     keywords.insert(make_pair(keyword, classID));
  102.   }
  103. }
  104.  
  105. unsigned int LanguageDefinition::generateNewKWClass(const string& newClassName){
  106.   unsigned int newClassID=0;
  107.   bool found=false;
  108.   while (newClassID<keywordClasses.size() && !found){
  109.    found= (newClassName==keywordClasses[newClassID++]);
  110.   }
  111.   if (!found){
  112.    newClassID++;
  113.    keywordClasses.push_back(newClassName);
  114.   }
  115.   return newClassID;
  116. }
  117.  
  118. unsigned int LanguageDefinition::getDelimPrefixClassID(const string& prefix){
  119.   if (delimiterPrefixes.count(prefix)){
  120.     return delimiterPrefixes[prefix];
  121.   }
  122.   return 0;
  123. }
  124.  
  125. bool LanguageDefinition::load(const string& langDefPath, bool clear)
  126. {
  127.   if (clear)  reset();
  128.  
  129.   ConfigurationReader langDef(langDefPath);
  130.   if (langDef.found())
  131.     {
  132.       currentPath=langDefPath;
  133.       disableHighlighting=false;
  134.       string token;
  135.       stringstream symbolStrStream;
  136.  
  137.       //Stringstream zum Einlesen der Token:
  138.       istringstream valueStream;
  139.  
  140.       addDelimiterSymbol(symbolStrStream, ML_COMMENT_BEGIN, ML_COMMENT_END,
  141.                          langDef.getParameter("ml_comment"));
  142.  
  143.       addSimpleSymbol(symbolStrStream, SL_COMMENT,
  144.                       langDef.getParameter("sl_comment"));
  145.  
  146.       addSimpleSymbol(symbolStrStream, ESC_CHAR,
  147.                       langDef.getParameter("escchar"));
  148.  
  149.       addSimpleSymbol(symbolStrStream, DIRECTIVE_LINE,
  150.                       langDef.getParameter("directive"));
  151.  
  152.       addSimpleSymbol(symbolStrStream, DIRECTIVE_LINE_END,
  153.                       langDef.getParameter("directiveend"));
  154.  
  155.       addSimpleSymbol(symbolStrStream, STRING,
  156.                       langDef.getParameter("stringdelimiters"));
  157.  
  158.       ignoreCase=getFlag(langDef.getParameter("ignorecase"));
  159.       allowNestedComments=getFlag(langDef.getParameter("allownestedcomments"));
  160.       vhdl_mode=getFlag(langDef.getParameter("vhdl_mode"));
  161.       java_mode=getFlag(langDef.getParameter("java_mode"));
  162.       disableHighlighting=getFlag(langDef.getParameter("disablehighlighting"));
  163.       fullLineComment=getFlag(langDef.getParameter("fl_comment"));
  164.       reformatCode=getFlag(langDef.getParameter("reformatting"));
  165.       rawStringPrefix=getSymbol(langDef.getParameter("rawstringprefix"));
  166.       continuationChar=getSymbol(langDef.getParameter("continuationsymbol"));
  167.       allowExtEscape=getFlag(langDef.getParameter("allowextescape"));
  168.  
  169.       string paramName, className, classValue;
  170.       vector<string> paramNames=langDef.getParameterNames();
  171.       for (unsigned int i=0;i<paramNames.size();i++){
  172.          paramName=paramNames[i];
  173.          className=StringTools::getParantheseVal(paramName);
  174.          classValue=langDef.getParameter(paramName);
  175.          if (paramName.find("kw_list") != string::npos ){
  176.            addKeywords(classValue, generateNewKWClass(className));
  177.          }
  178.          if (paramName.find("kw_prefix") != string::npos){
  179.            prefixes.insert(make_pair(classValue[0], generateNewKWClass(className)));
  180.          }
  181.          if (paramName.find("kw_delim") != string::npos ){
  182.           addDelimiterSymbol(symbolStrStream, KEYWORD_BEGIN, KEYWORD_END,
  183.                              classValue, generateNewKWClass(className));
  184.         }
  185.          if (paramName.find("tag_delim") != string::npos ){
  186.           addDelimiterSymbol(symbolStrStream, TAG_BEGIN, TAG_END,
  187.                              classValue, generateNewKWClass(className));
  188.         }
  189.       }
  190.  
  191.       // zuletzt einlesen, um Probleme mit Delimitern, die Zeichen der
  192.       // Symbolliste enthalten, zu vermeiden
  193.       addSimpleSymbol(symbolStrStream, SYMBOL, langDef.getParameter("symbols"));
  194.  
  195.       valueStream.str(langDef.getParameter("allowedchars"));
  196.       while (valueStream >> token )
  197.         {
  198.           allowedChars += token;
  199.         }
  200.       symbolString = symbolStrStream.str();
  201.  
  202.       string fileToInclude=langDef.getParameter("include");
  203.       if (!fileToInclude.empty()){
  204.         string::size_type Pos = langDefPath.find_last_of(Platform::pathSeparator);
  205.         string includeLangDefPath = langDefPath.substr(0, Pos+1) + fileToInclude;
  206.         load(includeLangDefPath, false);
  207.       }
  208.       return true;
  209.     }
  210.   else
  211.     {
  212.       currentPath.clear();
  213.       return false;
  214.     }
  215. }
  216.  
  217. void LanguageDefinition::reset()
  218. {
  219.   keywords.clear();
  220.   keywordClasses.clear();
  221.   delimiterPrefixes.clear();;
  222.   prefixes.clear();
  223.   allowedChars.clear();
  224.   ignoreCase= false;
  225.   java_mode= vhdl_mode= false;
  226.   allowNestedComments= reformatCode = false;
  227.   rawStringPrefix = continuationChar = '\0';
  228.   disableHighlighting=false;
  229.   fullLineComment=false;
  230. }
  231.  
  232. bool LanguageDefinition::isVHDL()
  233. {
  234.   return vhdl_mode;
  235. }
  236.  
  237. bool LanguageDefinition::isJava()
  238. {
  239.   return java_mode;
  240. }
  241.  
  242. bool LanguageDefinition::allowNestedMLComments(){
  243.   return allowNestedComments;
  244. }
  245.  
  246. bool LanguageDefinition::highlightingDisabled(){
  247.   return disableHighlighting;
  248. }
  249.  
  250. bool LanguageDefinition::isFullLineComment(){
  251.   return fullLineComment;
  252. }
  253.  
  254. bool LanguageDefinition::needsReload(const string &langDefPath){
  255.   return currentPath!=langDefPath;
  256. }
  257.  
  258. bool LanguageDefinition::enableReformatting(){
  259.   return reformatCode;
  260. }
  261.  
  262. const KeywordMap& LanguageDefinition::getKeywords() const{
  263.   return keywords;
  264. }
  265.  
  266. string &LanguageDefinition::getSymbolString() {
  267.   return symbolString;
  268. }
  269.  
  270. unsigned char LanguageDefinition::getRawStringPrefix(){
  271.   return rawStringPrefix;
  272. }
  273.  
  274. unsigned char LanguageDefinition::getContinuationChar(){
  275.   return continuationChar;
  276. }
  277.  
  278. string &LanguageDefinition::getAllowedChars() {
  279.   return allowedChars;
  280. }
  281.  
  282. bool LanguageDefinition::getSyntaxHighlight() {
  283.   return !disableHighlighting;
  284. }
  285.  
  286. bool LanguageDefinition::isIgnoreCase() {
  287.   return ignoreCase;
  288. }
  289.  
  290. const vector<string>&LanguageDefinition::getKeywordClasses() const{
  291.   return keywordClasses;
  292. }
  293.  
  294. bool LanguageDefinition::allowExtEscSeq() {
  295.     return allowExtEscape;
  296. }
  297.  
  298. }
  299.